home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / CUGUK / APPLICAT / C034.ZIP / DBQIEX.C < prev    next >
Text File  |  2010-11-01  |  5KB  |  275 lines
  1. /* SDB - import/export commands */
  2.  
  3. #include "bdscio.h"
  4. #include "dbqdefs.h"
  5.  
  6. int *db_import()
  7. {
  8.     struct scan *sptr;
  9.     struct attribute *aptr;
  10.     char fname[STRINGMAX+1],avalue[STRINGMAX+1];
  11.     int tcnt,astart,i,eofile;
  12.     FILE *fp;
  13.  
  14.     if (db_ntoken() == ID)
  15.         strcat(dbv_tstring,".dat");
  16.     else if (dbv_token != STRING)
  17.         { RETERR(SYNTAX) }
  18.     strcpy(fname,dbv_tstring);
  19.     if (db_ntoken() != INTO)
  20.         { RETERR(SYNTAX) }
  21.     if (db_ntoken() != ID)
  22.         { RETERR(SYNTAX) }
  23.  
  24.     if ((sptr = db_ropen(dbv_tstring)) == NULL)
  25.         return(FALSE);
  26.  
  27.     if ((fp = CALLOC(BUFSIZ)) == NULL) {
  28.         RETERR(INSMEM) }
  29.  
  30.     if ((fopen(fname,fp)) == ERROR) {
  31.         CFREE(fp);
  32.         RETERR(INPFNF)
  33.         }
  34. /*
  35.     if ((fp = fopen(fname,"r")) == NULL) /* OH NO NOT AGAIN */
  36.         { RETERR(INPFNF) }
  37. */
  38.     eofile = FALSE;
  39.     for (tcnt = 0; ; tcnt++) {
  40.  
  41.         astart = 1;
  42.         for (i = 0; i < NATTRS; i++) {
  43.             aptr = &sptr->sc_relation->rl_header.hd_attrs[i];
  44.  
  45.             if (aptr->at_name[0] == 0)
  46.                 break;
  47.  
  48.             if (fgets(avalue,fp) == 0) {
  49.                 eofile = TRUE;
  50.                 break;
  51.             }
  52.             avalue[strlen(avalue)-1] = EOS;
  53.  
  54.             db_aput(aptr,&sptr->sc_tuple[astart],avalue);
  55.  
  56.             astart += aptr->at_size;
  57.         }
  58.  
  59.         if (!eofile) {
  60.             if (!db_rstore(sptr)) {
  61.                 db_rclose(sptr);
  62.                 return (FALSE);
  63.             }
  64.         }
  65.         else
  66.             break;
  67.     }
  68.  
  69.     db_rclose(sptr);
  70.  
  71.     fclose(fp);
  72.     CFREE(fp);
  73.  
  74.     pcount(tcnt,"imported");
  75.  
  76.     return (TRUE);
  77. }
  78.  
  79. int *db_export()    /* remember to forget about fmt etc */
  80. {
  81.     struct scan *sptr;
  82.     struct attribute *aptr;
  83.     char rname[STRINGMAX+1],avalue[STRINGMAX+1];
  84.     int tcnt,astart,i,delflg;
  85.     FILE *fp;
  86.  
  87.     if (db_ntoken() != ID)
  88.         { RETERR(SYNTAX) }
  89.  
  90.     if (db_scmp(dbv_tstring,"deleted") == 0) {
  91.         delflg = TRUE;
  92.         if (db_ntoken() != ID)
  93.             { RETERR(SYNTAX) }
  94.         }
  95.     else
  96.         delflg = FALSE;
  97.  
  98.     strcpy(rname,dbv_tstring);
  99.  
  100.     if (!db_to(&fp,".dat"))
  101.         return(FALSE);
  102.  
  103.     if ((sptr = db_ropen(rname)) == NULL)
  104.         return(FALSE);
  105.  
  106.     for (tcnt = 0; dexport(sptr,delflg); tcnt++) {
  107.         astart = 1;
  108.         for (i = 0; i < NATTRS; i++) {
  109.  
  110.             aptr = &sptr->sc_relation->rl_header.hd_attrs[i];
  111.  
  112.             if (aptr->at_name[0] == 0)
  113.                 break;
  114.  
  115.             db_aget(aptr,&sptr->sc_tuple[astart],avalue);
  116.  
  117.             fprintf(fp,"%s\n",avalue);
  118.  
  119.             astart += aptr->at_size;
  120.         }
  121.     }
  122.  
  123.     db_rclose(sptr);
  124.  
  125.     if (fp != STDOUT)
  126.         fclose(fp);
  127.  
  128.     pcount(tcnt,"exported");
  129.  
  130.     return (TRUE);
  131. }
  132.  
  133. int dexport(sptr,delflg)
  134. struct scan *sptr; int delflg;
  135. {
  136.     if (delflg)
  137.         return (db_dfetch(sptr));
  138.     else
  139.         return (db_rfetch(sptr));
  140. }
  141.  
  142. int *db_squeeze()
  143. {
  144.     struct scan *sptr;
  145.  
  146.     if (db_ntoken() != ID)
  147.         { RETERR(SYNTAX) }
  148.  
  149.     if ((sptr = db_ropen(dbv_tstring)) == NULL)
  150.         return (FALSE);
  151.  
  152.     if (!db_rcompress(sptr)) {
  153.         db_rclose(sptr);
  154.         return (FALSE);
  155.     }
  156.  
  157.     db_rclose(sptr);
  158.  
  159.     return (TRUE);
  160. }
  161.  
  162. int *db_extract()
  163. {
  164.     struct scan *sptr;
  165.     struct attribute *aptr;
  166.     char rname[STRINGMAX+1],aname[ANSIZE+1],*atype;
  167.     int i;
  168.     FILE *fp;
  169.  
  170.     if (db_ntoken() != ID)
  171.         { RETERR(SYNTAX) }
  172.     strcpy(rname,dbv_tstring);
  173.     if (!db_to(&fp,".def"))
  174.         return (FALSE);
  175.  
  176.     if ((sptr = db_ropen(rname)) == NULL)
  177.         return (FALSE);
  178.  
  179.     fprintf(fp,"create %s\n",rname);
  180.  
  181.     for (i = 0; i < NATTRS; i++) {
  182.  
  183.         aptr = &sptr->sc_relation->rl_header.hd_attrs[i];
  184.  
  185.         if (aptr->at_name[0] == 0)
  186.             break;
  187.  
  188.         strncpy(aname,aptr->at_name,ANSIZE); aname[ANSIZE] = 0;
  189.  
  190.         switch (aptr->at_type) {
  191.         case TCHAR:
  192.             atype = "char";
  193.             break;
  194.         case TNUM:
  195.             atype = "num";
  196.             break;
  197.         default:
  198.             atype = "<error>";
  199.             break;
  200.         }
  201.  
  202.         if (strlen(aname) < 8)
  203.             fprintf(fp,"\t%s\t\t%s\t%d\t%d\n",aname,atype,
  204.                 aptr->at_size,aptr->at_scale);
  205.         else
  206.             fprintf(fp,"\t%s\t%s\t%d\t%d\n",aname,atype,
  207.                 aptr->at_size,aptr->at_scale);
  208.     }
  209.  
  210. /*    fprintf(fp,") %d\n",sptr->sc_relation->rl_tmax);    */
  211.     fprintf(fp,";\n");
  212.  
  213.     db_rclose(sptr);
  214.  
  215.     if (fp != STDOUT)
  216.         fclose(fp);
  217.  
  218.     return (TRUE);
  219. }
  220.  
  221.  
  222. int db_rcompress(sptr)
  223.     struct scan *sptr;
  224. {
  225.  
  226.     unsigned next,nextfree,tcnt;
  227.  
  228.     tcnt = sptr->sc_relation->rl_tcnt;
  229.  
  230.     for (next = nextfree = 1; next <= tcnt; next++) {
  231.  
  232.         tseek(sptr,next);
  233.         if (cread(sptr->sc_relation->rl_fd,
  234.             sptr->sc_tuple,sptr->sc_relation->rl_size)
  235.                 != sptr->sc_relation->rl_size)
  236.             { RETERR(TUPINP) }
  237.  
  238.         if (sptr->sc_tuple[0] == ACTIVE) {
  239.  
  240.             if (next != nextfree) {
  241.             tseek(sptr,nextfree);
  242.                 if (cwrite(sptr->sc_relation->rl_fd,
  243.                 sptr->sc_tuple,sptr->sc_relation->rl_size)
  244.                     != sptr->sc_relation->rl_size)
  245.                 { RETERR(TUPOUT) }
  246.             }
  247.  
  248.         nextfree += 1;
  249.         }
  250.     }
  251.  
  252.     nextfree--;
  253.  
  254.     tcnt = sptr->sc_relation->rl_tcnt - nextfree;
  255.     pcount(tcnt,"freed");
  256.  
  257.     sptr->sc_relation->rl_tcnt = nextfree;
  258.  
  259.     sptr->sc_atnum = sptr->sc_relation->rl_tcnt;
  260.  
  261.     sptr->sc_dtnum = 0;
  262.  
  263.     sptr->sc_store = TRUE;
  264.  
  265.     return (TRUE);
  266. }
  267.  
  268. ;
  269.  
  270.     sptr->sc_atnum = sptr->sc_relation->rl_tcnt;
  271.  
  272.     sptr->sc_dtnum = 0;
  273.  
  274.     sptr->sc_store = TRUE;
  275.